Parameters in Pure Type Systems

In this paper we study the addition of parameters to typed -calculus with definitions. We show that the resulting systems have nice properties and illustrate that parameters allow for a better fine-tuning of the strength of type systems as well as staying closer to type systems used in practice in theorem provers and programming languages. 1 What are parameters? Parameters occur when functions are only allowed to occur when provided with arguments. As we will show below, both in mathematics and in programming languages the use of parameters is abundant and closely connected to the use of constants and definitions. If we want to be able to use type systems in accordance with practice and yet described in a precise manner, we therefore need parameters, constants, and definitions in type theory as well. Parameters, constants and definitions in theorem proving It is interesting to note that the first tool for mechanical representation and verification of mathematical proofs, AUTOMATH, already has a combined constant, definition and parameter mechanism and was developed from the viewpoint of mathematicians (see [7]). The representation of a mathematical text in AUTOMATH consists of a finite list of lines where every line has the format: x1 : A1; : : : ; xn : An ` g(x1; : : : ; xn) = t : T . Here g is a new name; a constant if t is the acronym ‘primitive notion’, or an abbreviation (definition) for the expression t of type T , and x1; : : : ; xn are the parameters of g, with respective types A1; : : : ; An. Use of the definition g in the rest of the list of lines is only allowed when g is supplied with a list of arguments t1; : : : ; tn (with types conforming to A1; : : : ; An, see again [7]) to be substituted for the parameters of g. We see that parameters and definitions are a very substantial part of AUTOMATH since each line introduces a new constant or definition which is inherently parameterized by the variables occurring in the context needed for it. Actual development of ordinary mathematical theory in the AUTOMATH system by e.g. van Benthem Jutting (cf. [3]) revealed that this combined definition and parameter mechanism is vital for keeping proofs manageable and sufficiently readable for humans. ? Eindhoven University of Technology, Computing science, PO-Box 513, 5600 MB Eindhoven, The Netherlands, email: [email protected] ?? Heriot-Watt University, dept. of Computing and Electrical Eng., Edinburgh, Scotland, email: [email protected] ? ? ? email: [email protected] y Same address as Bloo, email: [email protected] Similar but more recent experience with the Coq proof system [10] suggests the same necessity of parameterized definitions, and indeed, state of the art theorem provers have parameter mechanisms as well. There is another advantage to the use of parameters. Allowing only parameters of a certain type and not the corresponding abstractions may yield a weaker type system. This can have advantages such as a first-order system instead of a higher-order one, or a simpler typecheck algorithm as has been observed for the type system P in [14]. Parameters, constants and definitions in programming languages Most non-assembly level programming languages have parameterized definitions as part of the syntax. Consider the Pascal definition of a function double: fun tion double(z : Integer) : Integer; begin double := z+ z end; The argument (z : Integer) is a parameter in our sense: the function double can only be used when given an argument, ergo double is a non-abstracted function. In ordinary -calculus this function double can only be represented by the -abstraction ( x : Int:(x + x)). This representation is unfaithful since this way double is a term on its own, of ‘higher-order character’ (it can be used without a parameter). For an example of the use of constants, we consider the programming language ML, which has the basic types int and list. However, list is not just an ordinary constant. It can only be used when given an argument (which is written prefix in ML) as in int list. We see that list is in fact a parameterized constant. 1.1 Extending pure type systems with parameters, constants and definitions There are many other examples of the frequent use of parameters in mathematics and computer science, occurring in combination with both definitions and constants. The general framework used to describe type systems, Pure Type Systems (PTSs, [2]), does not possess constants1 or parameters nor does it have syntax for definitions. Therefore we set out to extend pure type systems with parameters, constants and definitions in order to better be able to describe type systems used in practice. This work is based on the parameterized type systems of Laan in [12], although there are several subtle differences2 in the precise definition of the system. We first discuss work that has already been done in this direction. Two approaches are known for extending type theory with definitions. The first, by Severi and Poll, extends the syntax of -terms to include definitions [17]. The second only extends PTSs with global definitions (i.e., definitions in the context of derivations), and treats local definitions as ordinary -redexes [5]. 1 The role of unparameterized constants is usually imitated by variables, by agreeing not to make any abstraction over such variables. This is done in ordinary PTSs for the sorts and 2. Another extension of PTSs in which constants play an essential role are Modal PTSs, cf. [6]. 2 Definition 1 is slightly different, the rules (Cp-weak) and (Dp-weak) are now correct and we have a different treatment of topsorts in the rules for definitions. PTS [2] C-PTS D-PTS [17] Cp-PTS [11] CD-PTS Dp-PTS CpD-PTS CDp-PTS CpDp-PTS Fig. 1. The hierarchy of parameters, constants and definitions Both these approaches fail to model the definition of the double function from section 1 above, since they don’t have parameterized definitions. The best they can do is adding double = ( x:Int:x + x) : x:Int:Int to the context, which clearly isn’t in the spirit of Pascal where double on its own is not a valid expression. We shall call the extension of PTSs with unparameterized definitions D-PTSs. In this paper, we go one step further and introduce Dp-PTSs, pure type systems extended with parameterized definitions, so that we can imitate double by adding double(z : Int) = z + z : Int to the context. This will not allow the use of double unless it is provided an argument for its parameter z. This is an extension of the work of [17] on unparameterized definitions. Orthogonally, one can extend PTSs with parameterized constants as has been studied in [11]. We shall call these systems Cp-PTSs. Similar to the extension of PTSs with unparameterized definitions, one might consider PTSs extended with unparameterized constants only (C-PTSs). Although C-PTSs are not very interesting on their own, we include them here for symmetry reasons. Combining the various extensions, we obtain a hierarchy that can be depicted as in Figure 1. In this paper we study the top system in Figure 1, that is, PTSs extended with parameterized constants as well as parameterized definitions. Similar to the restrictions on the formation of abstractions in ordinary PTSs, it is natural to put restrictions on the formation of parameters as well. Although an unrestricted use of parameters may seem elegant from a theoretical point of view, this is not custom in programming languages. For instance, in many Pascal versions, parametric terms can only have parameters at term level. Therefore, in the CpDp-PTSs we study in this paper, in a parameterized term t(p1; : : : ; pn) we might want to restrict its formation according to the type of t(p1; : : : ; pn) as well as according to the types of the parameters p1; : : : ; pn. This paper is organized as follows: In Section 2, we define CpDp-PTSs, PTSs extended with parametric constants and definitions. This section includes an extension of the Æ-reduction of [17] to parametric definitions. In Section 3 we extend the theory in [17] to CpDp-PTSs. We show that our extended Æreduction (needed for unfolding definitions) and Æ-reductions are also confluent, and that the extended Æ-reduction (under reasonable conditions) is strongly normalizing. Then we show some elementary properties like the Generation Lemma, and the Subject Reduction property for Æreduction. Finally we prove that Æ-reduction in a CpDp-PTS is strongly normalizing if a slightly stronger PTS is -strongly normalizing. Section 4 is devoted to comparing CpDp-PTSs to ordinary PTSs. We show that for a large class of CpDp-PTSs there is a natural projection into an ordinary, but stronger, PTS. We conclude in Section 5. 2 Extending PTSs with parametric constants and definitions In this section, we extend Pure Type Systems (PTSs) (cf. [2]) with parameterized constants and parameterized definitions. Pure Type Systems (PTSs) were introduced by Berardi [4] and Terlouw [18] as a general framework in which many current type systems can be described. Though PTSs were not introduced before 1988, many rules in PTSs are highly influenced by rules of known type systems like Church’s Simple Theory of Types [8] and AUTOMATH (see 5.5.4. of [9]). The description of our extension of PTSs with parametric constants and definitions is based on the description of PTSs in [2]. Definition 1 Let V , C and S be disjoint sets of respectively variables, constants and sorts.3 The set TP of parametric terms is defined together with the set LV of lists of typed variables and the set LT of lists of terms by: TP ::= V j S j C(LT ) j (TP TP ) j ( V :TP :TP ) j ( V :TP :TP ) j (C(LV )=TP :TP in TP ); LV ::= ? j hLV ;V :TP i; LT ::= ? j hLT ; TP i: Instead of h hh?; x1:A1i; x2:A2i xn:Ani, we write hx1:A1; : : : ; xn:Ani or x1:A1; : : : ; xn:An. A similar convention is adopted for lists of terms. In a parametric term of the form (b1; : : : ; bn), the subterms b1; : : : ; bn are called the parameters of the term. Terms of the form C(LV )=TP :TP in TP represent parametric local definitions. An example of such a term is double(x:Int)=(x+x):Int in A which indicates that a subterm of A of the form double(P ) is to be interpreted as P + P , and has type Int. The definition is local, that is: the scope of the definition is the term A. Local definitions contrast with global definitions which are given in a context , and refer to any term that is considered within (see Definition 5). The definition system in AUTOMATH is similar to the system of global definitions in this paper. However, there are no local definitions in AUTOMATH. 3 Note that, in contrast to PTSs, we require the set of sorts to be disjoint from the set of (parametric) constants. Definition 2 Let !x :!A denote the list x1:A1; : : : ; xn:An. FV(A), the set of free variables of a parametric term A is defined as usual with the extra cases for constants and definitions: FV( (a1; : : : ; an)) = Sni=1 FV(ai); and FV( (!x :!A)=A:B in C) = Sni=1(FV(Ai) n fx1; : : : ; xi 1g) [ (FV(A) [ FV(B)) n fx1; : : : ; xng [ FV(C). We similarly define Cons(A), the set of constants and global definitions ofA as follows: Cons(s) = Cons(x) = ;; Cons( (a1; : : : ; an)) = f g [Sni=1 Cons(ai); Cons(AB) = Cons( x:A:B) = Cons( x:A:B) = Cons(A) [ Cons(B); Cons( (!x :!A)=A:B in C) = Sni=1 Cons(Ai) [ Cons(A) [ Cons(B) [ (Cons(C) n f g). FV(A) [ Cons(A) forms the domain Dom(A) of A. We omit parentheses in parametric terms when possible. As usual in PTSs (cf. [2]), we do not distinguish terms that are equal up to renaming of bound variables. Moreover, we assume the Barendregt variable convention so that names of bound variables and constants will always be chosen such that they differ from the free ones in a term. Definition 3 We extend the usual definition of substitution of a term a for a variable x in a term b, b[x:=a℄, to parametric terms, assuming that x is not a bound variable of either b or a: (b1; : : : ; bn)[x:=a℄ (b1[x:=a℄; : : : ; bn[x:=a℄); ( (!x :!A) = A:B in C)[x:=a℄ (x1:A1[x:=a℄; : : : ; xn:An[x:=a℄) = A[x:=a℄:B[x:=a℄ in C[x:=a℄: Definition 4 The set CP of contexts, which we denote by ; 0; : : : , is given by: CP ::= ? j hCP ;V :TP i j hCP ; C(LV )=TP :TP i j hCP ; C(LV ):TP i: Notice that LV CP : all lists of variable declarations are contexts as well. Definition 5 Let be a context. Declarations are elements of as follows: – x:A is a variable declaration with subject x and type A; – (x1:B1; : : : ; xn:Bn):A is a constant declaration with subject (also called primitive constant), parameters x1; : : : ; xn and type A; – (x1:B1; : : : ; xn:Bn)=a:A is a global definition (declaration) with subject (also called globally defined constant), parameters x1; : : : ; xn, definiens a and type A. Notation In the rest of this paper, denotes a context x1:B1; : : : ; xn:Bn consisting of variable declarations only. Such a context is typically used as a list of parameters in a definition ( )=a:A. We write i x1:B1; : : : ; xi 1:Bi 1 for i n. We extend the definition of substitution to contexts in the usual way. Definition 6 For a context we define FV( ) to be the set of subjects of variable declarations in and Cons( ) the set of subjects of constant declarations and global definitions in . The domain of , Dom( ), is defined as FV( ) [ Cons( ). In ordinary PTSs we have that, for a legal term A in a legal context , FV(A) FV( ). In our CpDp-PTSs we will have: FV(A) FV( ) and Cons(A) Cons( ). A natural condition on contexts is that all variables, primitive constants and defined constants are declared only once. Furthermore it is also natural to require that variables and constants are declared before they are being used. For this we introduce the notion of sound context: Definition 7 2 CP is sound if variables, primitive constants and defined constants are declared only once and if 1; ( )=a:A; 2 then Dom(a) [ Dom(A) Dom( 1) [ Dom( ) and for i = 1; : : : ; n: Dom(Bi) Dom( 1; i): The contexts occurring in the type systems proposed in this paper are all sound (see Lemma 15). This fact will be useful when proving properties of these systems. We now start a more detailed description of the top system in Figure 1, the system with both parameterized defined constants and parameterized primitive constants. We define two reduction relations, namely the Æand -reduction. -reduction is defined as usual, and we use ! , ! , !+ , and = as usual. As far as global definitions are concerned, Æ-reduction is comparable to Æ-reduction in AUTOMATH. This is reflected in rule (Æ1) in Figure 2 and Definition 8 below. But now, a Æ-reduction step can also unfold local definitions. Therefore, two new reduction steps are introduced. Rule (Æ2) removes the declaration of a local definition if there is no position within its scope where it can be unfolded (‘removal of void local definitions’). Rule (Æ3) shows how one can treat a local definition as a global definition, and thus how the problem of unfolding local definitions can be reduced to unfolding global definitions (‘localization of global definitions’). Remember that x1:B1; : : : ; xn:Bn. Definition 8 (Æ-reduction) Æ-reduction is defined as the smallest relation !Æ on CP TP TP closed under the rules (Æ1), (Æ2), (Æ3) and the compatibility rules of Figure 2. ` =Æ denotes the reflexive, symmetric and transitive closure of ` !Æ . When is the empty context, we write a!Æ a0 instead of ` a!Æ a0. Furthermore Æ-reduction between contexts is the smallest relation !Æ on CP CP closed under the rules in Figure 3. Before describing the typing rules for CpDp-PTSs, we introduce the concepts of specification (taken from [2]) and parametric specification. Definition 9 (Specification) A specification is a triple (S;A;R), such that S C, A S S and R S S S. The specification is called singly sorted if A is a (partial) function S ! S, and R is a (partial) function S S ! S. S is called the set of sorts, A is the set of axioms, and R is the set of ( -formation) rules of the specification. A parametric specification is a quadruple (S;A;R;P ) such that (S;A;R) is a specification, and the set of parametric rules P S S. The parametric specification is called singly sorted if the specification (S;A;R) is singly sorted. We first give the typing rules for ordinary terms of PTSs. These can also be found in [2]. Definition 10 (Typing rules for ordinary terms) Let S = (S;A;R) be a specification. The Pure Type System S describes in which ways judgements `S A : B (or (Æ1): 1; ( )=a:A; 2 ` (b1; : : : ; bn) !Æ a[xi:=bi℄ni=1 (Æ2): 62 Cons(b) ` ( )=a:A in b!Æ b (Æ3): ; ( )=a:A ` b!Æ b0 ` ( )=a:A in b!Æ ( )=a:A in b0 ; ` a!Æ a0 ` ( )=a:A in b!Æ ( )=a0:A in b ; ` A!Æ A0 ` ( )=a:A in b!Æ ( )=a:A0 in b ; i ` Bi !Æ B0 i ` ( )=a:A in b!Æ (x1:B1; : : : ; xi:B0 i; : : : ; xn:Bn)=a:A in b ` a!Æ a0 ` ab!Æ a0b ` b!Æ b0 ` ab!Æ ab0 ; x:A ` a!Æ a0 ` x:A:a!Æ x:A:a0 ` A!Æ A0 ` x:A:a!Æ x:A0:a ; x:A ` a!Æ a0 ` x:A:a!Æ x:A:a0 ` A!Æ A0 ` x:A:a!Æ x:A0:a ` aj !Æ a0j ` (a1; : : : ; an) !Æ (a1; : : : ; a0j ; : : : ; an) Fig. 2. Reduction rules and compatibility rules for !Æ 1 ` A!Æ A0 1; x:A; 2 !Æ 1; x:A0; 2 1; !Æ 1; 0 1; ( ):A; 2 !Æ 1; ( 0):A; 2 1; ` A!Æ A0 1; ( ):A; 2 !Æ 1; ( ):A0; 2 1; ` a!Æ a0 1; ( )=a:A; 2 !Æ 1; ( )=a0:A; 2 1; !Æ 1; 0 1; ( )=a:A; 2 !Æ 1; ( 0)=a:A; 2 1; ` A!Æ A0 1; ( )=a:A; 2 !Æ 1; ( )=a:A0; 2 Fig. 3. Rules for Æ-reduction on contexts ` A : B, if it is clear which S is used) can be derived. ` A : B states that A has type B in context . S consists of the derivation rules given in Figure 4. A term a is legal (with respect to a certain type system) if there are , b such that either ` a : b or ` b : a is derivable (in that type system). Similarly, a context is legal if there are a, b such that ` a : b. A sort s 2 S is called topsort if there is no context and s0 2 S such that ` s : s0. An important class of examples of PTSs is formed by the eight PTSs of the so-called Barendregt Cube. The Barendregt Cube is a three-dimensional presentation of eight well-known PTSs. All systems have sorts S = f ;2g, and axioms A = f( ;2)g. Moreover, all the systems have rule ( ; ; ). System ! has no extra rules, but the other seven systems all have one or more of the rules ( ;2;2), (2; ; ) and (2;2;2). (axiom) hi ` s1 : s2 (s1; s2) 2 A (start) ` A : s ; x:A ` x : A x 62 Dom( ) (weak) ` A : B ` C : s ; x:C ` A : B x 62 Dom( ) ( ) ` A : s1 ; x:A ` B : s2 ` ( x:A:B) : s3 (s1; s2; s3) 2 R ( ) ; x:A ` b : B ` ( x:A:B) : s ` ( x:A:b) : ( x:A:B) (appl) ` F : ( x:A:B) ` a : A ` Fa : B[x:=a℄ (conv) ` A : B ` B0 : s B = B0 ` A : B0 Fig. 4. Typing rules for PTSs (Cp-weak) `Cp b:B ; `Cp A:s ; i `Cp Bi:si (si; s) 2 P (i = 1; : : : ; n) ; ( ) : A `Cp b : B (Cp-app) 1; ( ):A; 2 `Cp bi:Bi[xj :=bj ℄i 1 j=1 (i = 1; : : : ; n) 1; ( ):A; 2 `Cp A : s (if n = 0) 1; ( ):A; 2 `Cp (b1; : : : ; bn) : A[xj :=bj ℄nj=1 Fig. 5. Typing rules for parametric constants Now we add rules for typing parametric constants. In these rules we use the set of parametric rules P to govern which types parameters can have. Definition 11 (Typing rules for parametric constants) Let S = (S;A;R;P ) be a parametric specification. The typing relation `Cp is the smallest relation on CP TP TP closed under the rules in Definition 10 and the rules (Cp-weak) and (Cp-app) in Figure 5. Recall that x1:B1; : : : ; xn:Bn and s 2 S. The parameterized constant in the Cp-weakening rule is, due to the Barendregt variable convention, assumed to be -fresh, that is, = 2 Cons( ). At first sight one might miss a Cp-introduction rule. Such a rule, however, is not necessary, as (on its own) is not a term. A parameterized constant can only be (part of) a term in the form (b1; : : : ; bn), and such terms can be typed by the Cp-application rule. The extra condition 1; ( ):A; 2 `Cp A : s in the Cp-application rule for n = 0 is necessary to prevent an empty list of premises. Such an empty list of premises would make it possible to have almost arbitrary contexts in the conclusion. The extra condition is only needed to assure that the context in the conclusion is a legal context. (Dp-weak) `Dp b:B ; `Dp a:A:s ; i `Dp Bi:si (si; s) 2 P (i=1; : : : ; n) ; ( )=a:A `Dp b : B (Dp-app) 1; ( )=a:A; 2 `Dp bi : Bi[xj :=bj ℄i 1 j=1 (i = 1; : : : ; n) 1; ( )=a:A; 2 `Dp a : A (if n = 0) 1; ( )=a:A; 2 `Dp (b1; : : : ; bn) : A[xj :=bj ℄nj=1 (Dp-form) ; ( )=a:A `Dp B : s `Dp ( )=a:A in B : s (Dp-intro) ; ( )=a:A `Dp b : B `Dp ( )=a:A in B : s `Dp ( )=a:A in b : ( )=a:A in B (Dp-conv) `Dp b : B `Dp B0 : s ` B =Æ B0 `Dp b : B0 Fig. 6. Typing rules for parametric definitions Note that in the (Cp-weak) rule it is not necessary that all the si are equal: in one application of rule (Cp-weak) it is possible to rely on more than one element of P . Remark 12 If we have a parametric constant plus(x:Int; y:Int):Int in the context, then it is tempting to think of plus as a parametric function. Note however that in PTSterms it is not a function anymore since the only way to obtain a legal term with it is in its parameterized form plus(x; y) which has type Int; plus(x:Int; y:Int) itself is not a legal term. In order to talk about properties of plus ‘as a function’ we are forced to consider x:Int: y:Int:plus(x; y). Adapting the rules from Definition 11 and the rules for definitions of [17] results in rules for parametric definitions (by ` a : A : s we mean ` a : A and ` A : s): Definition 13 (Typing rules for parametric definitions) The typing relation `Dp is the smallest relation on CP TP TP closed under the rules in Definition 10 and those in Figure 6, where s 2 S, and the parameterized definition that is introduced in the Dp-weakening rule is assumed to be -fresh. Again it is not necessary that all the si in the (Dp-weak) rule are equal. Definition 14 (CpDp-PTSs) Let S = (S;A;R;P ) be a parametric specification. Then `CpDp is the smallest relation on CP TP TP that is closed under the rules of Definitions 10, 11 and 13. The CpDp-PTS CpDpS is the system with typing relation `CpDp . All contexts occurring in CpDp-PTSs are sound (see Definition 7). As CpDp-PTSs are clearly extensions of PTSs, Cp-PTSs and Dp-PTSs, then all contexts occurring in PTSs, Cp-PTSs and Dp-PTSs are sound. Lemma 15 Assume `CpDp b : B. Then 1. Dom(b);Dom(B) Dom( ); 2. is sound. PROOF: We prove 1 and 2 simultaneously by induction on the derivation of `CpDp b : B. In the specific case of the Barendregt Cube, the combination of R and P leads to a refinement of the Cube, thus making it possible to classify more type systems within one and the same framework. This is studied in detail for PTSs extended with parameterized constants (without definitions) in [11]; it is shown that the type systems of AUTOMATH, LF and ML can be described more naturally and accurately than in ordinary PTSs. Remark 16 Let S = (S;A;R) be a specification, and observe the parametric specification S 0 = (S;A;R;?). The fact that the set of parametric rules is empty does not exclude the existence of definitions: it is still possible to apply the rules (Dp-weak) and (Dp-app) for n = 0. In that case, we obtain only definitions without parameters, and the rules of the parametric system reduce to the rules of a D-PTS with specification S as introduced by [17].4 There is however one case of the rules in [17] that a CpDp-PTS cannot simulate, since in rule (Dp-weak) we require ; `Dp A : s which [17] does not. Therefore, the system of [17] can abbreviate inhabitants of topsorts which is impossible in the CpDp-PTSs of Definition 14. We feel that abbreviating inhabitants of topsorts is not very useful. It is however routine to check that adding an extra rule (Dp-weak-top) `Dp b : B ; `Dp a : A ; () = a : A `Dp b : B does not change the theory of CpDp-PTSs developed in sections 3 and 4, and yields exactly the same power for unparameterized definitions as the D-PTSs of [17].